#include "../include/double_Sql_list.h"

// 双向链表的创建
Double_Link_List *init_double_link_list()
{
    // 创建头节点的动态空间
    Double_Link_List *list = (Double_Link_List *)malloc(sizeof(Double_Link_List));
    if (NULL == list)
    {
        ERRLOG("动态空间创建失败");
        return NULL;
    }
    list->next = NULL;

    return list;
}

// 双向链表的插入
void insert_double_node(Double_Link_List *list, Log_in_data data, int pos)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }
    // 1、 创建新空间
    Double_Node *new_node = (Double_Node *)malloc(sizeof(Double_Node));
    if (NULL == list)
    {
        ERRLOG("动态空间创建失败");
        return;
    }
    // 初始化
    new_node->data = data;
    new_node->next = NULL;
    new_node->prev = NULL;

    // 2 头插
    if (1 == pos)
    {
        // 1 将 new_node 的 next 指向 头结点 的next
        new_node->next = list->next;
        // 2 将 头结点的 next 结点 的 prev 指向 new_node
        //   需要进行if判断 如果 list->next = NULL 则不需要这一步
        if (NULL != list->next)
        {
            list->next->prev = new_node;
        }
        // 3 将 list->next 指向 new_node
        list->next = new_node;

        return;
    }

    // 任意位置插入
    Double_Node *ptr = list->next;

    for (size_t i = 1; i < pos - 1 && NULL != ptr; i++)
    {
        ptr = ptr->next;
    }
    
    if (NULL == ptr)
    {
        ERRLOG("ptr == NULL");
        free(new_node);
        return;
    }

    // 开始插入
    //  1、 将 new_node 的 next 指向 ptr 的next
    new_node->next = ptr->next;
    //  2、 将 ptr 的 next 的 prev 指向 new_node
    if (NULL != ptr->next)
    {
        ptr->next->prev = new_node;
    }
    //  3、 将 new_node 的 prev 指向 prt
    new_node->prev = ptr;
    //  4、 将 ptr 的next 指向 new_node
    ptr->next = new_node;

    return;
}


// 双向链表的遍历
void print_forward_double_link_list(Double_Link_List *list)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }

    Double_Node *ptr = list->next;

    for (size_t i = 0; NULL != ptr; i++)
    {
        printf("账号:%s\t密码:%s\tid:%c\n", ptr->data.name, ptr->data.password, ptr->data.id);
        ptr = ptr->next;
    }

    return;
}
void print_backwards_double_link_list(Double_Link_List *list);

// 查找函数
Double_Node* find_double_node_name(Double_Link_List* list, char* name)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("传入的表内为空");
        return NULL;
    }

    Double_Node * ptr = list->next;

    for (size_t i = 0; NULL != ptr; i++)
    {
        if (!strcmp(ptr->data.name , name))
        {
            printf("找到了\n");
            return ptr;
        }
        ptr = ptr->next;
    }
    
    return NULL;
    
}

// 双向链表的删除
Log_in_data delete_double_node(Double_Link_List* list, int pos)
{
    Log_in_data delete_data;
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return delete_data;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表内无数据");
        return delete_data;
    }
    // 头删
    if (1 == pos)
    {
        Double_Node * ptr = list->next;
        // 1、将头节点 指向 ptr 的next
        list->next = ptr->next;
        // 2、将 ptr 的 next 的 prev 指向 NULL
        ptr->next->prev = NULL;

        // 将数据写入到 要返回的变量中
        delete_data = ptr->data;

        // 3、释放ptr空间
        free(ptr);

        return delete_data;
    }

    // 任意位置删除
    Double_Node * ptr_1 = list->next;
    Double_Node * ptr_2 = ptr_1->next;

    for (size_t i = 1; i < pos - 1 && NULL != ptr_1->next; i++)
    {
        ptr_1 = ptr_1->next;
        ptr_2 = ptr_1->next;
    }
    
    if (NULL == ptr_1->next)
    {
        ERRLOG("删除访问越界\n");
        return delete_data;
    }
    
    // 删除

    // 1、 ptr_1 的next 指向 ptr_2 的next
    ptr_1->next = ptr_2->next;
    // 2、 pre_2 的 next 的 prev 指向 ptr_1
    if (NULL != ptr_2->next)
    {
        ptr_2->next->prev = ptr_1;
    }

    // 将数据写入到 要返回的变量中
    delete_data = ptr_2->data;

    // 3、释放
    free(ptr_2);

    return delete_data;

}

Double_Node * delete_double_node_name(Double_Link_List* list, char * name)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表内无数据");
        return NULL;
    }

    Double_Node * ptr = list->next;
    size_t i = 0;
    for ( i = 0; NULL != ptr; i++)
    {
        if (!strcmp(ptr->data.name , name))
        {
            delete_double_node(list , i + 1);
            return ptr;
        }
        ptr = ptr->next;
    }
    
    return NULL;
}

// 双向链表的清空
void clear_double_link_list(Double_Link_List* list)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }
    // 无数据的清空
    if (NULL == list->next)
    {
        ERRLOG("链表内无数据");
        return;
    }
    // 有数据的清空
    Double_Node * ptr_1 = list->next;
    Double_Node * ptr_2 = ptr_1->next;

    for (size_t i = 0; NULL != ptr_2 ; i++)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if (NULL != ptr_2)
        {
            ptr_2 = ptr_2->next;
        }
        list->next = NULL;
    }
    return ;
}

// 双向链表的销毁
void free_double_link_list(Double_Link_List ** list)
{
    if (NULL == *list)
    {
        ERRLOG("链表的动态空间为空");
        return;
    }
    // 无数据的清空
    if (NULL == (*list)->next)
    {
        ERRLOG("链表内无数据");
        free(*list);
        *list = NULL;
        return;
    }

    // 有数据的清空
    Double_Node * ptr_1 = (*list)->next;
    Double_Node * ptr_2 = ptr_1->next;

    for (size_t i = 0; NULL != ptr_1 ; i++)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if (NULL != ptr_2)
        {
            ptr_2 = ptr_2->next;
        }
    }

    free(*list);
    *list = NULL;

    return ;
}


